package com.gxc.array;

import java.util.Arrays;
import java.util.Scanner;

/**
 * 流浪地球计划在赤道上均匀部署了N个转向发动机，按位置顺序编号为0~N-1。
 *
 * 初始状态下所有的发动机都是未启动状态;
 * 发动机启动的方式分为”手动启动"和”关联启动"两种方式;
 * 如果在时刻1一个发动机被启动，下一个时刻2与之相邻的两个发动机就会被”关联启动”;
 * 如果准备启动某个发动机时，它已经被启动了，则什么都不用做;
 * 发动机0与发动机N-1是相邻的;
 * 地球联合政府准备挑选某些发动机在某些时刻进行“手动启动”。当然最终所有的发动机都会被启动。
 *
 * 哪些发动机最晚被启动呢?
 *
 * 输入描述
 * 第一行两个数字N和E，中间有空格
 * N代表部署发动机的总个数，E代表计划手动启动的发动机总个数
 * 1<N<=1000,1<=E<=1000,E<=N
 * 接下来共E行，每行都是两个数字T和P，中间有空格
 * T代表发动机的手动启动时刻，P代表此发动机的位置编号。
 * 0<=T<=N.0<=P<N
 * 输出描述
 * 第一行一个数字N，以回车结束
 * N代表最后被启动的发动机个数
 * 第二行N个数字，中间有空格，以回车结束
 * 每个数字代表发动机的位置编号，从小到大排序
 */
public class LatestMachine {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String[] s1 = scanner.nextLine().split(" ");
        int n = Integer.parseInt(s1[0]);
        int e = Integer.parseInt(s1[1]);

        int[] engineStatuses = new int[n];
        int earliestActivation = Integer.MAX_VALUE;
        Arrays.fill(engineStatuses, -1);
        for (int i = 0; i < e; i++) {
            String[] timeIndex = scanner.nextLine().split(" ");
            int activationTime = Integer.parseInt(timeIndex[0]);
            int engineIndex = Integer.parseInt(timeIndex[1]);
            engineStatuses[engineIndex] = activationTime;
            earliestActivation = Math.min(earliestActivation, activationTime);
        }
        scanner.close();

        updateEngineStatuses(engineStatuses, earliestActivation);  // 根据最早的激活时间开始更新状态
    }

    private static void updateEngineStatuses(int[] engineStatuses, int startTime) {
        boolean continueUpdate = true;
        while (continueUpdate) {
            for (int i = 0; i < engineStatuses.length; i++) {
                if (engineStatuses[i] == startTime) {
                    activateAdjacentEngines(engineStatuses, i, startTime + 1, engineStatuses.length);  // 激活当前引擎的相邻引擎
                }
            }
            startTime++;  // 增加时间步长，检查下一个时间点
            continueUpdate = hasInactiveEngines(engineStatuses, startTime);  // 检查是否还有未激活的引擎
        }

        int maxTime = Arrays.stream(engineStatuses).max().getAsInt();
        int count = 0;
        StringBuilder builder = new StringBuilder();
        for (int i = 0; i < engineStatuses.length; i++) {
            if (engineStatuses[i] == maxTime) {
                count++;
                builder.append(i).append(" ");
            }
        }
        System.out.println(count);
        System.out.println(builder.toString().trim());
    }

    private static void activateAdjacentEngines(int[] engineStatuses, int index, int startTime, int length) {
        int leftIndex = index==0 ? length-1 : index-1;
        int rightIndex = index == length -1 ? 0: index + 1;
        if (engineStatuses[leftIndex]  == -1 || engineStatuses[leftIndex] > startTime) {
            engineStatuses[leftIndex] = startTime;
        }
        if (engineStatuses[rightIndex]  == -1 || engineStatuses[rightIndex] > startTime) {
            engineStatuses[rightIndex] = startTime;
        }
    }

    // 检查数组中是否有引擎处于未激活状态（即状态为 -1）
    public static boolean hasInactiveEngines(int[] engineStatuses, int startTime) {
        return Arrays.stream(engineStatuses).anyMatch(a -> a == -1 || a > startTime);
    }
}
